\chapter{Introduction}
\pagenumbering{arabic}%

\sysname{} is an implementation-independent framework for creating
\commonlisp{} compilers. 

It is implementation-independent in that it provides:

\begin{itemize}
\item general features that every implementation needs,
\item features that implementations can optionally choose to take
  advantage of, 
\item alternative features that are appropriate for some
  implementations and not for others,
\item mechanisms for allowing implementation-specific features that
  integrate seamlessly into the general framework.
\end{itemize}

To use the framework, an implementation provides methods for a few
generic functions that allow \sysname{} to access the compilation and
evaluation environments of the implementation.  \sysname{} uses those
functions to turn a form into an \emph{abstract syntax tree}, or AST.
\seechap{chap-abstract-syntax-tree} \sysname{} then translates the AST
into an intermediate representation called HIR.%
\footnote{HIR stands for High-level Intermediate Representation.}
\seechap{chap-ir}
This translation can be customized by the implementation.  \sysname{}
then provides a number of transformations on this representation such
as:

\begin{itemize}
\item translation into \emph{static single assignment} form,
\item type inference,
\item standard optimizations such as value numbering, common
  subexpression elimination, redundancy elimination, etc.
\end{itemize}

Once these implementation-independent and backend-independent
transformations have been accomplished, the HIR notation is gradually
transformed into a notation that is specific both to the
implementation and to the backend.  The result of the first step of
this transformation is an intermediate form called MIR.%
\footnote{MIR means Medium-level Intermediate Representation.}  MIR
differs from HIR in that it exposes address calculations and memory
accesses using those addresses, whereas HIR manipulates only
\commonlisp{} objects.  A number of optimizations can be applied to
MIR before it is translated to LIR.%
\footnote{LIR means Low-level Intermediate Representation.}
LIR differens from MIR in that it introduces features such as
registers and stack frames.  The notation also becomes implementation
specific in that it exposes choices such as argument passing.

Finally, the low-level code is translated into machine code.

At each stage, an implementation can customize the process by
introducing new classes and methods. 
